System and method for detecting interpreter-based exploit attacks

ABSTRACT

For one embodiment, a computerized method for detecting exploit attacks on an interpreter comprises configuring a virtual machine including a user mode and a kernel mode and processing an object by an application operating in the user mode of the virtual machine. Responsive to the processing of the object, detecting a loading of an interpreter. Furthermore, responsive to the loading of the interpreter, inserting one or more intercept points for detecting one or more types of software calls from the interpreter or for detecting a certain type or certain types of activities occurring within the interpreter. Thereafter, an exploit attack is detected as being conducted by the object in response to the interpreter invoking a software call that corresponds to the one or more types of software calls that is considered anomalous when invoked by the interpreter or an anomalous activity being conducted within the interpreter.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation application of U.S. patent application Ser. No. 14/869,901 filed Sep. 29, 2015, now U.S. Pat. No. 10,033,747 issued Jul. 24, 2018, the entire contents of both of which are incorporated by reference herein.

FIELD

Embodiments of the disclosure relate to the field of malware detection. More specifically, one embodiment of the disclosure relates to a threat detection system that is adapted to detect exploit attacks, especially on an interpreter deployed within in kernel mode or user mode.

GENERAL BACKGROUND

Over the last decade, network devices that access the Internet or other publicly accessible networks have been increasingly subjected to malicious attacks. These malicious attacks may simply involve the use of stolen credentials by an unauthorized person in efforts to illicitly gain access to information stored within a network device. However, other malicious attacks may be more complex.

In general, a malicious attack may be carried out as an exploit attack. An exploit attack is an attempt to take advantage of a vulnerability in computer software or systems by adversely influencing or attacking normal operations of a targeted computer. Typically, exploit attacks are conducted as “user-mode” attacks, where a vulnerability associated with a specific application (e.g., web browser, PDF reader application, Microsoft® Office®) operating in user mode is targeted. In User mode (lesser privileged operating domain such as Ring-3), an executing application has no ability to directly access system resources (e.g., physical or virtual hardware). Instead, the executing application utilizes system-based functions, such as Application Programming Interfaces (APIs) for example, to access the system resources.

Recently, however, there have been an increased level of exploit attacks targeting certain plug-ins as software components operating within the kernel mode. The “kernel mode” is a privileged mode, where a processor in this mode can access the entire address space and execute the entire instruction set (privileged and non-privileged instructions). In kernel mode, an executing software component normally has complete and unrestricted access to the underlying system resources. Hence, kernel mode is generally reserved for low-level, trusted functions of the operating system. One of these targeted software components is a script interpreter.

A script interpreter is a software component that is configured to interpret and execute a script, namely code that is not native to an operating system for the electronic device targeted to receive the script, but features a higher level construct. The script interpreter typically translates content of the scripts (e.g., instructions within bytecode from an interpreted flash file, command lines from an interpreted JavaScript®, etc.) in context of a corresponding application. For ease of deployment, when a receiving electronic device is implemented with a particular script interpreter, such as kernel-based font interpreter (e.g., in win32k.sys) that is operating in kernel mode and having a higher privileged access to resources within the electronic device than an application running in the user mode for example, content within a received script is commonly translated from non-native to native code. In other words, the bytecode instructions or higher-level language code are translated without any consideration that the script may be malicious. Thereafter, after being interpreted (i.e. converted from non-native to native code for execution), the script is executed.

Scripts placed within documents or web pages are typically interpreted and executed within the application's container. This allows for vulnerabilities in the interpreter to be exploited by constructing specific conditions in the script, where early stage detection of an exploit attack on the interpreter is extremely difficult. Once an exploit is triggered, one type of malicious code injected by the script (referred to as “shellcode”) may execute and compromise the receiving electronic device and perhaps an entire network if the malicious attack can propagate to other devices. The shellcode may cause the interpreter to perform operations beyond its limited functionality. Additionally, after the shellcode has executed, full remediation of the shellcode may be difficult to achieve.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the disclosure are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which:

FIG. 1 is an exemplary block diagram of a physical representation of an electronic device.

FIG. 2 is a first embodiment of the electronic device of FIG. 1 employing a threat detection system.

FIG. 3 is an exemplary embodiment of a physical representation of the electronic device of FIG. 2 deploying the threat detection system.

FIG. 4 is a second embodiment of the electronic device of FIG. 1 employing a threat detection system.

FIG. 5 is an exemplary embodiment of a stack illustrating a flow of operations controlled by the hook framework and instrumentation framework within the kernel driver of the threat detection system.

FIG. 6 is an exemplary embodiment of an endpoint device that features a security agent for detecting exploit attacks on an interpreter.

DETAILED DESCRIPTION

Various embodiments of the disclosure are directed to a threat detection system for detecting and classifying malicious attacks, and in particular exploit attacks on particular software components. The critical commonality for these types of exploit attacks is that the software component, such as an interpreter operating in user mode or kernel mode, is tricked into invoking malicious code such as shellcode. “Shellcode” refers to a small piece of executable code that resides in data (e.g., injected into data), which is used as a payload of malware, and, in some cases, contains a shell command to execute an exploit. The interpreter is designed to perform a limited set of activities, which may include interpret certain instructions in a script. These activities may be monitored by monitoring signaling that is triggered from calls from an interpreter and/or operations conducted by the interpreter. The signaling from the interpreter may be monitored through intercept point (sometimes referred to as “hooks”) to certain software calls (e.g., Application Programming Interface “API” call, library, procedure, function, or system call). The operations of the interpreter may be monitored through another type of intercept point (herein sometimes referred to as “instrumentation”) into code closely operating with the interpreter code or within the interpreter code itself to detect a certain type of activity, which may include an activity prompting a particular software call, is anomalous (e.g., abnormal, unexpected, etc.).

An exploit attack on a particular interpreter may cause the interpreter, based on execution of the shellcode, to perform one or more activities beyond this limited set of activities. Hence, exploit attacks may be determined in response to the use of these intercept points to detect that (i) the functionality of the interpreter exceeds the expected functionality for that particular type of interpreter or (ii) the interpreter performs certain unexpected functionality being monitored. Herein, for a virtual machine based deployment, the interpreter may reside in kernel mode or user mode. In another deployment, the interpreter may be invoked during run-time.

More specifically, with respect to one embodiment of the disclosure, based on software contained in a memory and executed by one or more hardware processors, a virtual machine is adapted to include a kernel driver, which is configured with one or more interception point frameworks (hereinafter referred to as “interception point framework(s)”) along with monitoring logic that collectively (i) detects certain types of activities that are outside the limited set of activities expected for a particular interpreter, (ii) determines that one or more of these detected activities are anomalous (e.g., unexpected, abnormal, etc.) upon confirmation that the particular interpreter initiated such activity through analysis of the calling hierarchy and other parameters (e.g., stack analysis or call trace review), and (iii) stores information associated with the anomalous activity. Hence, the detection and classification of exploit attacks on an interpreter focus on this behavior, where one or more activities conducted by the interpreter are anomalous, namely the one or more activities fall outside a correlated set of expected activities or fall within a correlated set of unexpected (abnormal) activities. The detection of one or more anomalous activities may indicate a potential exploit attack is being attempted.

According to one embodiment of the disclosure, the interception point framework(s) may include a hook framework, which detects certain activities involving system-related functions, including at least a presence of a function call that invokes a particular Application Programming Interface (API) for example, and tracks usage of that particular API. The hook framework may be configured to intercept (sometimes referred to as “hook”) different types of API calls, depending on the type or the types of interpreters (e.g., Flash, JavaScript®, Virtual Basic “VB”, etc.) being protected by the threat detection system. It is contemplated that “hooked” API calls monitored for one type of interpreter may be mutually exclusive or may include some or all of the hooked API calls monitored for another type of interpreter. A hooked API call invoked when the interpreter is part of the calling hierarchy would be monitored for presence of an anomalous (and potentially malicious) activity, which may cause classification logic within the threat detection system to conclude that an object under analysis is malicious and an exploit attack is being conducted on that interpreter.

More specifically, the hook framework is configured to intercept (hook) API calls. In response to initiating a hooked API call, a thread of execution, which pertains to the interpreter interpreting content from a script under analysis within the virtual machine that generated the API call, is halted until a response to the hooked API call is returned. Monitoring logic operating in cooperation with the hook framework tracks usage of the APIs corresponding to the hooked API calls, where usage of some APIs by the interpreter may be considered an anomalous activity. Responsive to the hooked API calls, virtualized system resources return information (e.g., pointer, data, etc.) to the hook framework, which routes the returned information to the thread of execution so that the interpreter continues virtual processing of the script. During processing of the script or after processing of the script has completed, the monitoring logic provides information associated with any detected anomalous activity or activities to classification logic to determine whether any detected anomalous activities denote an exploit attack on the interpreter.

The interception point framework(s) may further include an instrumentation framework, which utilizes interception points (herein also referred to as “instrumentations”) that are placed within code associated with the interpreter to detect certain activities. Namely, according to one embodiment of the disclosure, each instrumentation (e.g., an inserted breakpoint, JUMP instruction, etc.) may be placed within code closely operating with the interpreter code or within the interpreter code itself. The instrumentations selected for monitoring one type of interpreter may partially or completely differ from those instrumentations selected for monitoring another type of interpreter. The instrumentation framework provides a higher level view of script processing, namely detailed state information associated with the interpreter at a time when the instrumentation is triggered. At that time, a thread of execution associated with the interpreter, which is interpreting content from a script under analysis with the virtual machine, is temporarily halted until processing control is returned to the interpreter. Monitoring logic operating in cooperation with the instrumentation framework tracks the triggering of the instrumentations and gathers state information of the interpreter when the instrumentations are triggered.

Stated differently, the instrumentation framework includes one or more instrumentations that, when accessed during script processing by the interpreter, cause processing of the script to be temporarily halted. At that time, the monitoring logic gains access to state information associated with the interpreter. The state information may include the memory location being accessed when the instrumentation hook is invoked, call trace information, the number of threads running, or the like. Thereafter, processing control is returned to the interpreter and the processing of the script continues.

As an illustrative example, suppose an interpreter is configured to only interpret simple memory and arithmetic instructions and perform relevant memory operations. Based on the type of interpreter, instrumentations associated with certain functionality of the interpreter may be set and/or API call hooks to intercept certain “anomalous” API calls for that type of interpreter may be set. During processing of an object (e.g., file, document, or other information including a script) within a virtual machine (VM), anomalous activities by the interpreter (e.g., new memory allocations, version checks, new thread creation etc.) are detected. Such detection may be accomplished by intercepting of anomalous activities by the interpreter through any of the interception point frameworks, followed by confirmation that the activities appear to have been initiated by the interpreter. The detection of these anomalous activities may identify that the interpreter is subject to an exploit attack. Thereafter, automated classification and reporting of the anomalous activities (along with data associated with the potential exploit attack) is conducted to ensure that a centralized management system or administrator is aware of the exploit attack.

It is contemplated that one or more interception point frameworks and monitoring logic may be deployed within an electronic device (i) as a kernel driver, or (ii) as part of a hypervisor. Interception points (hooks) directed to the hook framework may be placed into monitor logic (e.g., a dynamic linked library “DLL” code) injected into an application that utilizes an interpreter. The instrumentations may be placed into monitor logic injected to the interpreter.

Herein, the electronic device may be a standalone appliance adapted to receive data for analysis from a data source (e.g., a digital tap or connector that provides connectivity to a network, dedicated device from which data can be directly uploaded via a dedicated interconnect or peer-to-peer connection, etc.). Alternatively, the electronic device may be an endpoint device (e.g., cellular telephone, laptop computer, etc.) or any other electronic device with network connectivity capabilities.

The disclosure is directed to a system that detects malicious (e.g., exploit) attacks on various types of interpreters, where the system is scalable and is programmable where the interception frameworks may be configured to monitor for anomalous activity from different types of interpreters. The malware detection may be applicable to malware detection in kernel mode, such as VM-based kernel exploit detection for example, or in user mode. It is contemplated that, in lieu of detection of an exploit attack on an interpreter as described, the system may be utilized for detecting exploit attacks on another logic type, such as a Just-In-Time (JIT) compiler for example, where the compiler is instrumented and, as it generates code, intercept points may be placed into the code. The intercept points are used to detect API calls and instrumentation activities within the compiler itself.

I. Terminology

In the following description, certain terminology is used to describe features of the invention. For example, in certain situations, the terms “component” and “logic” are representative of hardware, firmware or software that is configured to perform one or more functions. As hardware, a component (or logic) may include circuitry having data processing or storage functionality. Examples of such circuitry may include, but are not limited or restricted to a hardware processor (e.g., microprocessor with one or more processor cores, a digital signal processor, a programmable gate array, a microcontroller, an application specific integrated circuit “ASIC”, etc.), a semiconductor memory, or combinatorial elements.

A component (or logic) may be software in the form of one or more software modules, such as executable code or an instance, an API, a subroutine, a function, a procedure, an applet, a servlet, a routine, source code, object code, a shared library/dynamic link library, or even one or more instructions. These software modules may be stored in any type of a suitable non-transitory storage medium, or transitory storage medium (e.g., electrical, optical, acoustical or other form of propagated signals such as carrier waves, infrared signals, or digital signals). Examples of non-transitory storage medium may include, but are not limited or restricted to a programmable circuit; semiconductor memory; non-persistent storage such as volatile memory (e.g., any type of random access memory “RAM”); or persistent storage such as non-volatile memory (e.g., read-only memory “ROM”, power-backed RAM, flash memory, phase-change memory, etc.), a solid-state drive, hard disk drive, an optical disc drive, or a portable memory device. As firmware, the executable code may be stored in persistent storage.

The term “object” generally refers to a collection of data, whether in transit (e.g., over a network) or at rest (e.g., stored), often having a logical structure or organization that enables it to be classified for purposes of analysis for malware. During analysis, for example, the object may exhibit certain expected characteristics (e.g., expected internal content such as bit patterns, data structures, etc.) and, during processing, conduct certain expected activities. The object may also exhibit unexpected characteristics or conduct a set of unexpected activities that may offer evidence of the presence of malware (exploit) and potentially allow the object to be classified as part of a malicious (exploit) attack.

Examples of objects may include one or more flows or a self-contained element within a flow itself. A “flow” generally refers to related packets that are received, transmitted, or exchanged within a communication session. For convenience, a packet is broadly referred to as a series of bits or bytes having a prescribed format, which may, according to one embodiment, include packets, frames, or cells. Further, an object may correspond to a collection of data that may take the form of an individual or a number of packets carrying related payloads, e.g., a single webpage received over a network. Moreover, an object may be a file retrieved from a storage location over an interconnect.

As a self-contained element, the object may be an executable (e.g., an application, program, segment of code, dynamically link library “DLL”, etc.) or a non-executable. Examples of non-executables may include a document (e.g., a Portable Document Format “PDF” document, Microsoft® Office® document, Microsoft® Excel® spreadsheet, etc.), an electronic mail (email), downloaded web page, or the like.

The term “activity” should be generally construed as a behavior conducted by a software component running on the computing device. The activity may occur that causes an undesired action to occur, such as stealing system tokens, injecting system code into a high privileged process, or modify kernel code that is involved at a higher privilege for example.

The term “framework” denotes an abstraction in which the corresponding software provides generic and configurable functionality that can be selectively changed.

The term “electronic device” should be generally construed as electronics with the data processing capability and/or a capability of connecting to any type of network, such as a public network (e.g., Internet), a private network (e.g., a wireless data telecommunication network, a local area network “LAN”, etc.), or a combination of networks. Examples of an electronic device may include, but are not limited or restricted to, the following: an endpoint device (e.g., a laptop, a smartphone, a tablet, a desktop computer, a netbook, a medical device, or any general-purpose or special-purpose, user-controlled electronic device configured to support virtualization); a server; a mainframe; a router; or a security appliance that includes any system or subsystem configured to perform functions associated with malware detection and may be communicatively coupled to a network to intercept data routed to or from an endpoint device.

According to one embodiment, the term “malware” may be construed broadly as any code or activity that initiates a malicious attack and/or operations associated with anomalous or unwanted behavior. For instance, malware may correspond to a type of malicious computer code that executes an exploit to take advantage of a vulnerability, for example, to harm or co-opt operation of a network device or misappropriate, modify or delete data. In the alternative, malware may correspond to an exploit, namely information (e.g., executable code, data, command(s), etc.) that attempts to take advantage of a vulnerability in software and/or an action by a person gaining unauthorized access to one or more areas of a network device to cause the network device to experience undesirable or anomalous behaviors. The undesirable or anomalous behaviors may include a communication-based anomaly or an execution-based anomaly, which, for example, could (1) alter the functionality of an network device executing application software in an atypical manner (a file is opened by a first process where the file is configured to be opened by a second process and not the first process); (2) alter the functionality of the network device executing that application software without any malicious intent; and/or (3) provide unwanted functionality which may be generally acceptable in another context. Additionally, malware may be code that initiates unwanted behavior which may be, as one example, uploading a contact list from an endpoint device to cloud storage without receiving permission from the user.

The term “interconnect” may be construed as a physical or logical communication path between two or more electronic devices. For instance, the communication path may include wired or wireless transmission mediums. Examples of wired transmission mediums and wireless transmission mediums may include electrical wiring, optical fiber, cable, bus trace, a radio unit that supports radio frequency (RF) signaling, or any other wired/wireless signal transfer mechanism.

The term “computerized” generally represents that any corresponding operations are conducted by hardware in combination with software or firmware.

Lastly, the terms “or” and “and/or” as used herein are to be interpreted as inclusive or meaning any one or any combination. Therefore, “A, B or C” or “A, B and/or C” mean “any of the following: A; B; C; A and B; A and C; B and C; A, B and C.” An exception to this definition will occur only when a combination of elements, functions, steps or acts are in some way inherently mutually exclusive.

II. General System Architecture

Referring now to FIG. 1, an exemplary block diagram of a physical representation of an electronic device 100 (e.g., security appliance, endpoint device, etc.) is shown, where the electronic device 100 is configured as a threat detection system adapted to detect exploit attacks on an interpreter 180. The interpreter 180 may be deployed within kernel space or within user space of system memory. Herein, the electronic device 100 comprises one or more hardware processors (referred to as “processor(s)”) 110, a memory 120, one or more network interfaces (referred to as “network interface(s)”) 130, and one or more network devices (referred to as “network device(s)”) 140 connected by a system interconnect 150, such as a bus. These components are at least partially encased in a housing 160, which is made entirely or partially of a rigid material (e.g., hardened plastic, metal, glass, composite, or any combination thereof) that protects these components from atmospheric conditions.

The processor(s) 110 is a multipurpose, programmable device that accepts digital data as input, processes the input data according to instructions stored in its system memory, and provides results as output. One example of a processor may include an Intel® x86 central processing unit (CPU) with an instruction set architecture. Alternatively, a processor may include another type of CPU, a digital signal processor (DSP), an Application Specific Integrated Circuit (ASIC), a field-programmable gate array (FPGA), or the like.

The network device(s) 140 may include various input/output (I/O) or peripheral devices, such as a keyboard, key pad, touch screen, or mouse for example. Each network interface 130 may include one or more network ports containing the mechanical, electrical and/or signaling circuitry needed to connect the electronic device 100 to a network to thereby facilitate communications to other remotely located electronic devices. To that end, the network interface(s) 130 may be configured to transmit and/or receive messages using a variety of communication protocols including, inter alia, Transmission Control Protocol/Internet Protocol (TCP/IP), Hypertext Transfer Protocol (HTTP), or HTTP Secure (HTTPS).

The memory 120 operates as system memory that may include different storage device types such as semiconductor memory (e.g., any type or random access memory, any type programmable read-only memory such as flash memory or any type of electrically erasable programmable read-only memory “EEPROM”) or a storage device. One type of storage device may include a solid state drive (SSD) or a hard disk drive (HDD) into which one or more interpreters 180 (e.g., script interpreters) may be stored. From a logical perspective, the memory 120 includes a plurality of locations that are addressable by the processor(s) 110 and the network interface(s) 130 for storing software components (including software applications) and data structures associated with such software components. Examples of the stored software components may include some or all of the following: an operating system (OS) 170, one or more software applications 175, and/or one or more interpreters 180 which may be provided as guest software (residing in user space) or host software (residing in kernel space). An optional virtual machine monitor (sometimes referred to as a “VMM” or a “hypervisor”) 190 and/or optional virtual system resources 195 may be other stored components.

The OS 170, resident in memory 120 and executed by the hardware processor(s) 110, functionally organizes the electronic device 100 by, inter alia, invoking operations in support of applications executing on the electronic device 100. Herein, the OS 170 features a kernel 172 running in the most privileged level (Ring-0). Examples of types of OSes may include, but are not limited or restricted to the following: (1) a version of a WINDOWS® series of operating system; (2) a version of a MAC OS® or an IOS® series of operating system; (3) a version of a LINUX® operating system; or (4) a versions of an ANDROID® operating system, among others.

A kernel driver 174 is loaded into the kernel 172 when a virtual machine (VM), which is used for in-depth, sandboxed analysis of an object for detecting a presence of a malware, is launched. The kernel driver 174 comprises interception point frameworks 176 and/or 178, which are configured to (i) intercept and monitor for certain types of activities conducted during processing of one or more interpreters 180 (hereinafter “interpreters”) that are outside the limited set of activities expected for a particular interpreter being monitored, and (ii) determine that a detected activity is anomalous (e.g., unexpected, abnormal, etc.) upon confirmation that the particular interpreter initiated or is being utilized during such activity. The confirmation may involve an analysis that the particular interpreter is part of the calling hierarchy through an analysis of a call stack or call trace review.

III. Architecture of the Threat Detection System

As shown in FIG. 2, a first embodiment of the electronic device 100 employing a threat detection system 200 is shown. The thread detection system 200 operates within the electronic device 100 and is adapted to analyze an object associated with incoming data (e.g., network traffic propagating over a communication network 210, input data from another type of transmission medium including a dedicated transmission medium, etc.). According to this illustrative embodiment, the threat detection system 200 may be communicatively coupled with the communication network 210 via an interface 220, where the communication network 210 may include a public network such as the Internet, a private network (e.g., a local area network “LAN”, wireless LAN, etc.), or a combination thereof. The interface 220 operates as a data capturing device that intercepts (or alternatively duplicates) at least a portion of the received data, namely an object for analysis 222 and/or metadata associated with the incoming object 222. Alternatively, although not shown, the interface 220 may be configured to receive files or other types of objects that are not provided over a network. For instance, as an illustrative example, the interface 220 may be a data capturing device that automatically (or on command) accesses data stored in a storage system or another type of interface, such as a port, for receiving objects manually provided via a suitable dedicated communication link or from storage media such as portable flash drives.

In some embodiments, although not shown, interface 220 may be contained within the electronic device 100 as part of the threat detection system 200. In other embodiments, the interface 220 can be integrated into an intermediary device in the communication path (e.g., an optional firewall, router, switch or other networked electronic device) or can be a standalone component, such as an appropriate commercially available network tap.

For this illustrative embodiment, however, the interface 220 may be configured to capture data associated with the incoming object 222 for analysis, and perhaps its corresponding metadata (or generate metadata based on the captured data). The metadata may be used, at least in part by the formatting logic 230, to determine protocols, application types and other information that may be used by other logic (e.g., a scheduler 250 or a virtual machine monitor not shown) within the threat detection system 200 to determine a particular software profile used in virtual machine (VM) configuration and/or VM operation scheduling. For instance, one or more software profiles may be used for selecting and configuring one or more virtual machines (e.g., VM 262) operating within dynamic analysis logic 260. These software profile(s) may be directed to different software or different versions of the same software application extracted from software image(s) fetched from a storage device 255.

As further shown in FIG. 2, the threat detection system 200 includes the formatting logic 230, static analysis logic 240, the scheduler 250, the storage device 255, dynamic analysis logic 260, classification logic 285, and/or reporting logic 290. Herein, according to this embodiment of the disclosure, the formatting logic 230 receives the incoming object 222 and converts that object into a format, if needed or as appropriate, on which scanning may be conducted by the static analysis logic 240. This conversion may involve decompression of the object for example. It is contemplated that the formatting logic 230 may conduct de-compilation, disassembly or other de-obfuscation activities on the object 222 and/or extraction of specific data associated with the object 222. However, as shown below, the de-obfuscation and data extraction activities may be handled by logic within the static analysis logic 240.

Referring still to FIG. 2, the static analysis logic 240 comprises de-obfuscation logic 242, analysis logic 244 and extraction logic 246. The de-obfuscation logic 242 is configured to de-obfuscate at least a portion of the formatted object 224 received from the formatting logic 230. As an example, the de-obfuscation logic 242 may be configured to de-obfuscate, such as decompile or disassemble, at least a portion of the formatted object 224 (e.g., a flash file, a document or a web page with an embedded script) to recover a script 225.

After de-obfuscation, as an optional analysis stage, the analysis logic 244 may analyze content within the script 225 that has been extracted from the formatted object 224. Such analysis may include, but is not limited or restricted to, an analysis of the script type and an analysis for the presence of certain API calls within the script 225. In response to determining that the script 225 includes content that, at run-time, would issue a particular API call, the extraction logic 246 may extract one or more characteristics (hereinafter “characteristic(s)”) associated with the script 225, such as the script type, targeted interpreter name, function name coded to issue the particular API call, the API name, data associated with the size of the formatted object 224, or the like. According to this embodiment of the disclosure, the extracted characteristic(s) may be provided as static analysis (SA)-based results 245 to activity inspection logic 287 of the classification logic 285 for subsequent analysis. Additionally or in the alternative, the analysis logic 244 may analyze content within the script 225 by performing one or more checks on content associated with the script 225 without its execution. Examples of the checks may include signature checks, which may involve a comparison of content that is part of the high-level representation of the script 225 to one or more pre-stored signatures associated with content that, within a script executed by a particular interpreter, would be anomalous.

Additionally, or in the alternative, after de-obfuscation, the analysis logic 244 analyzes content within the formatted object 224. As before, the analysis may include, but is not limited or restricted to, an analysis to determine the type of object (e.g., flash file, uniform resource locator “URL”, web page, etc.), the presence of a script with the formatted object 224, the script type, and/or the presence of certain API calls within the script. In response to determining that the formatted object 224 includes content that includes a script (e.g. flash file) or has a high propensity for executing a script at run-time (e.g., URL), the extraction logic 246 may extract characteristic(s) associated with the object (e.g., object name, object type, size, path, domain name, or query string). According to this embodiment of the disclosure, the extracted characteristic(s) may be provided as static analysis (SA)-based results 245 to activity inspection logic 287 of the classification logic 285 for subsequent analysis. The analysis logic 244 may analyze content within the formatted object 224 by performing one or more checks on such content without execution of the formatted object 224.

It is contemplated that the static analysis logic 240 may further include processing circuitry (not shown) that is responsible for extracting or generating metadata contained within or otherwise associated with incoming data from the formatting logic 230 (e.g., network traffic, downloaded data). This metadata may be subsequently used for configuring one or more VMs (e.g., VM 262) within the dynamic analysis logic 260 for conducting a dynamic analysis of an object associated with that metadata.

Additionally, after analysis of the formatted object 224 or script 225 has been completed, the static analysis logic 240 may provide at least some of the information associated with the analyzed formatted object 224 or script 225 (hereinafter generally referred to as “suspicious object” 226) to the dynamic analysis logic 260 for in-depth dynamic analysis by the VM 262. For instance, according to one embodiment of the disclosure, the VM 262 may be adapted to run an application 270 that processes the suspicious object 226 in user mode 264. During processing of the suspicious object 226, the application 270 may need a particular interpreter 272 operating in kernel mode 266 as shown (or operating in user mode 264 depending on the script type) to parse and/or process information that is part of the suspicious object 226. For instance, where the suspicious object 226 is a flash file, during processing by application 270, a group of instructions within bytecode is interpreted by a flash interpreter (in user mode 264) into native code that is executed. Where the suspicious object 226 is JavaScript®, during processing by application 270, the JavaScript® interpreter (in user mode 264) parses each command line and interprets the same into native code for subsequent execution. Where the suspicious object 226 is a font file, during processing by application 270, a group of instructions within bytecode is interpreted by the font interpreter (in kernel mode 266) into native code that is executed.

According to one embodiment, in operation alongside the interpreter 272, a kernel driver 274 is loaded into the kernel 266. Operating in kernel mode, the kernel driver 274 comprises interception point frameworks 276 and/or 278, which are configured to intercept and monitor certain types of activities exhibited during processing of the suspicious object 226 within the VM 262. These interception point frameworks comprise a hook framework 276 and an instrumentation framework 278. The kernel driver 274 further comprises monitoring logic 280 and correlation logic 282 operating in concert with the interception point frameworks 276 and/or 278.

After loading, the kernel driver 274 conducts a multi-stage initialization process in response to a launching of the application 270 for processing the suspicious object 226. During the launch of the application 270, monitor logic 271 is loaded. During or after loading of the monitor logic 271, the hook framework 276 may insert intercept points (sometimes referred to as “hooks”) at certain locations within the monitor logic 271 to allow the hook framework 276 to intercept one or more function calls 277, which may be Application Programming Interface (API) call(s), in order to track usage of that particular API. These “hooked” API calls may vary from one object type (and corresponding interpreter) to another, but normally are not mutually exclusive (i.e. partial overlap exists). An API (system) call 277 directed to one of the hooked APIs, where usage of the API call by an interpreter being part of the calling hierarchy might be considered an anomalous (and potentially malicious) activity, is intercepted by the hook framework 276. Information associated with the API call 277 may be extracted and stored for subsequent use by the classification logic 285 within the threat detection system 200 in its determination as to whether the suspicious object 226 is malicious and whether an exploit attack is being conducted on the interpreter 272.

More specifically, the hook framework 276 is configured to intercept certain API calls 277 associated with a certain type activity (or certain types of activities), including a system call directed to an API that is normally not accessed by the particular interpreter 272. In response to initiating the API call 277, a thread that is processing a portion of the script that initiated the API call 277 is halted until a response to the API call 277 is returned. The monitoring logic 280 tracks usage of certain APIs, especially any API invoked while the interpreter 272 is part of the calling hierarchy (e.g., by the interpreter 272 or logic operating in conjunction with the interpreter). In some embodiments, an attempted access to these certain APIs by the interpreter 272 (blacklist access control) may be considered an anomalous activity. In other embodiments, the interpreter 272 deviating by invoking an API call other than the certain APIs (whitelist access control) may be considered an anomalous activity.

Virtualized system resources (not shown) returns information (e.g., pointer, data, etc.) in response to the API call and virtual processing of the script continues. During virtual processing or after virtual processing of the script has completed, the monitoring logic 280 and the correlation logic 282 may be configured to provide information associated with any detected anomalous activity or activities to the classification logic 285, which determines whether any detected anomalous activities denote an exploit attack on the interpreter 272.

In summary, the hook framework 276 may be used to intercept one or more selected API calls or equivalent operating system (e.g., guest or host OS) function calls that are considered anomalous API calls for that particular interpreter 272. The hook framework 276 includes logic that extract one or more features (e.g., arguments, etc.) from the API call 277. Similarly, these features may include a name of the function identified in the function call (e.g., API name), or other data within the arguments of the function call issued (or triggered) by the suspicious object 226 during processing within the VM 262. The features may be stored in a data store 284 and are subsequently provided to (or accessible by) the classification logic 285 as part of VM-based results 279.

It is contemplated that, although not shown, where the interpreter 272 is deployed within the user mode 264, such as for the handling of flash or JAVASCRIPT® for example, it is contemplated that the monitor logic 271 may be configured with the functionality of the hook framework 276, the instrumentation framework 278, the monitoring logic 280 and the correlation logic 282 in order to obtain control of the processing flow at the user level. For example, the hook framework 276 may be configured to intercept calls associated from a script residing within the application 270, such as an API call 277 directed to the kernel driver 274 or any other of function calls directed to user-mode resources or kernel-based resources. The monitoring logic 280 may be configured to track behavior of the script (and the virtual machine 262 at large) based on the monitored API calls or accesses to functions to determine whether such behavior is anomalous. The correlation logic 282 may be configured to provide information associated with any detected anomalous activity or activities to the classification logic 285.

As another alternative, in lieu of API hooking, traps instructions may be set so that control is diverted to a hypervisor or logic within the user mode 264 itself.

Referring still to FIG. 2, during execution of the suspicious object 226, the application 270 may load the interpreter 272. Around that time, the instrumentation framework 278 may insert intercept points (referred to as “instrumentations”) to detect a certain type of activity that is anomalous (e.g., abnormal, unexpected, etc.) for that interpreter. This activity may correspond to an attempted access to a certain function of the interpreter 272. Namely, each instrumentation may be placed within code operating in concert with the interpreter 272 or within the monitored interpreter code itself. The instrumentation for one type of interpreter may readily differ from an instrumentation for another type of interpreter. The instrumentation framework 278 provides a higher level view of script processing, by collecting higher level state information associated with the interpreter 272. To be stored in the data store 284 and subsequently provided to (or accessible by) the classification logic 285 as part of VM-based results 279, the state information may include the memory location being accessed when the instrumentation is triggered, call trace information, the number of threads running, or the like. The thread that invoked the instrumentation is temporarily halted, and after capturing information associated with this monitored activity, the halt is released and processing of suspicious object 226 by the interpreter 272 may continue.

Herein, the scheduler 250 may be adapted to configure one or more VMs (e.g. VM 262) based on metadata associated with the suspicious object 226 in order to conduct run-time processing of the suspicious object 226 within the configured VM 262. Although not shown, for a multiple VM deployment, a first VM and a second VM may be configured to run concurrently (i.e. overlapping at least in part in time), where each of these VMs may be configured with different software profiles corresponding to software images stored within the storage device 255. As an alternative embodiment, the VM 262 may be configured to run plural processes concurrently or sequentially, each process configured according to a software configuration that may be used by different electronic devices or prevalent types of software configurations (e.g., a particular version of Windows® OS or a particular version of a web browser with a particular application plug-in). It is contemplated that the VM configuration described above may be handled by logic other than the scheduler 250.

According to one embodiment of the disclosure, the dynamic analysis logic 260 features one or more VMs, where each generally simulates the processing of the suspicious object 226 within a run-time environment. For instance, as an optional feature, the dynamic analysis logic 260 may include processing logic 261 that is configured to provide anticipated signaling to the VM 262 during virtual processing of the suspicious object 226, and as such, emulates a source of or destination for communications with the suspicious object 226 while processed within the VM 262. As an example, the processing logic 261 may be adapted to operate by providing simulated key inputs from a keyboard, keypad or touch screen or providing certain signaling, as requested by the suspicious object 226 during run-time.

As shown in FIG. 2, the static analysis logic 240 may be adapted to provide SA-based results 245 to the classification logic 285 while the dynamic analysis logic 260 may be adapted to provide the VM-based results 279 to the classification logic 285. According to one embodiment of the disclosure, the SA-based results 245 may include information obtained by analyzing the formatted object 224 that is potentially indicative of malware (e.g., function names, object size, suspicious strings within the object 224). Similarly, the VM-based results 279 may include information associated with the suspicious object 226 as well as the function calls that invoke abnormal API calls or unexpected functions for example.

According to one embodiment of the disclosure, the classification logic 285 includes the activity inspection logic 287 that is configured to receive the SA-based results 245 and/or the VM-based results 279. Based at least partially on the SA-based results 245 and/or VM-based results 279, the activity inspection logic 287 evaluates the characteristic(s) within the SA-based results 245 and/or the monitored activities associated with the VM-based results 279 to determine whether the suspicious object 226 should be classified as “malicious”. The evaluation may receive one or more features as input, either individually or as a pattern of two or more features, and produces a result that may be used to identify whether the suspicious object 226 is associated with a malicious attack. Alternatively, the evaluation may be based on data acquired through machine learning.

For instance, provided with the VM-based results 279, the activity inspection logic 287 may conduct a probabilistic modeling process that assigns risk levels to different activities captured by the dynamic analysis logic 260. The risk levels may be aggregated to produce a value that denotes whether the suspicious object 226 is malicious (i.e. associated with an exploit attack on the interpreter 272). Upon determining that the interpreter 272 is subject to an exploit attack, the classification logic 285 may provide information 289 to identify the malicious object, including information that identifies one or more of the monitored activities, to the reporting logic 290.

The reporting logic 290 is configured to receive information 289 from the classification logic 285 and generate alert signals 292, especially in response to the suspicious object 226 being now classified as malicious. The alert signals 292 may include various types of messages, which may include text messages, email messages, video or audio stream, or other types of information over a wired or wireless communication path. The reporting logic 290 features an optional user interface 294 (e.g., touch pad, keyed inputs, etc.) for customization as to the reporting configuration.

Referring now to FIG. 3, an exemplary embodiment of a physical representation of the electronic device 100 deploying the threat detection system 200 of FIG. 2 is shown. The electronic device 100 features the housing 160, which is made entirely or partially of a rigid material (e.g., hardened plastic, metal, glass, composite or any combination thereof) that protect circuitry within the housing 160. Coupled via a first transmission medium 300, the circuitry is coupled to communication interface logic 310, which may be implemented as one of the network interfaces 130, namely a physical interface including one or more ports for wired connectors. Additionally, or in the alternative, the communication interface logic 310 may be implemented as one or more radio units for supporting wireless communications with other electronic devices.

A persistent storage 330 is configured to store software components that are part of the threat detection system, namely the kernel driver 274 implemented with at least interception point frameworks 276 and/or 278 and monitoring logic 280. The software components are processed by processor(s) 110 communicatively coupled to the persistent storage 330 via a second transmission medium 320. The persistent storage 330 may be a combination of the memory 120 and at least one of the network devices 140 that may include a device with a large amount of storage capability such as a solid state drive (SSD) or a hard disk drive (HDD).

According to one embodiment of the disclosure, the persistent storage 330 may include (a) the static analysis logic 240; (b) the dynamic analysis logic 260; (c) classification logic 285; (d) reporting logic 290; and/or (e) one or more data stores 340 that may be utilized by static analysis logic 240, dynamic analysis logic 260, classification logic 285 including activity inspection logic 287, and/or reporting logic 290. One or more of these logic units could be implemented externally from the threat detection system 200.

Additionally, the persistent storage 330 further stores one or more interpreters 272 and the kernel driver 274, which is loaded as part of the kernel code utilized by a virtual machine that is in operation during processing of the dynamic analysis logic 260. The kernel driver 274 may comprises the hook framework 276, the instrumentation framework 278, monitoring logic 280, and correlation logic 282. Alternately, the monitor logic 271 may be configured with the functionality of the hook framework 276, the instrumentation framework 278, the monitoring logic 280, and the correlation logic 282 to detect exploit attacks on the interpreter 272 that resides in the user mode 264. As described above, both the hook framework 276 and the instrumentation framework 278 are configured to (i) detect certain types of activities that are outside the limited set of activities expected for a particular interpreter 272 and (ii) determine that one or more of these detected activities are anomalous (e.g., unexpected, abnormal, etc.) upon confirmation that the particular interpreter 272 initiated such activity through analysis of the calling hierarchy (e.g., stack analysis or call trace review). Hook framework 276 is configured to detect functions calls directed to APIs or other OS functions to access system resources 268 that may represent an anomalous activity while the instrumentation framework 278 is configured to detect access to certain functions within or closely interacting with the interpreter 272 that may also represent a non-anomalous activity.

The information associated with the monitored API calls or accesses to functions with the interpreter is monitored by the monitoring logic 280. Given that multiple processes or threads involving interpreter operations may be operating concurrently, or multiple processes or threads associated with different interpreters may be operating concurrently, the correlation logic 282 is adapted to aggregate monitored data in accordance with any desired grouping. One grouping may be based on the suspicious object under analysis. Another grouping may be based on interpreter type.

An activity reporting logic 360 formats data received from the monitoring logic 280 and correlation logic 282, which aggregates and categorizes the monitored data received from the hook framework 276 and/or instrumentation framework 278. The activity reporting logic 360 is responsible for re-formatting the data received from the monitoring logic 280 (and/or correlation logic 282) into a format that is recognized and used by the classification logic 285.

When implemented as hardware circuitry, the static analysis engine 240 may be configured to be communicatively coupled to communication interface logic 310 and/or the classification engine 285. The dynamic analysis engine 260 may further be communicatively coupled to the communication interface logic 310, the static analysis engine 240, and/or the classification engine 285. The classification engine 285 is communicatively coupled to the reporting logic 290.

Referring now to FIG. 4, a second embodiment of the electronic device 100 employing the threat detection system 200 is shown. Herein, the formatting logic 430, static analysis logic 440, scheduler 450, storage device 455, classification logic 485, and/or reporting logic 490 operate similarly to the formatting logic 230, static analysis logic 240, scheduler 250, storage device 255, classification logic 285, and/or reporting logic 290 of FIG. 2. However, the dynamic analysis logic 460, which is responsible for conducting in-depth dynamic analysis of the suspicious object 226, comprises two or more virtual machines (VM) 462 ₁-462 _(M) (M>1), which provides processing capabilities for the suspicious object 226 within a virtual run-time environment. For instance, the dynamic analysis engine 460 comprises a virtual machine monitor (VMM) 463, sometimes referred to as a “hypervisor,” which is configured to detect and classify calls received from the VMs 462 ₁-462 _(M).

Additionally, the VMM 463 may emulate and provide anticipated signaling to the VM(s) 462 ₁, . . . , and/or 462 _(M) during virtual processing. As an example, the VMM 463 may be configured to obtain information associated with the call received from one of the VMs 462 ₁-462 _(M) (e.g., VM 462 ₁). For instance, when the VMM 463 detects a call, virtual machine memory inspection logic “VM_MI” (not shown), which is part of the VMM 463, accesses certain portions of the virtualized system resources 468 (e.g., one or more registers of the virtual processor “vCPU”, virtualized memory, etc.) to identify the type of call detected. The VMM 463 may obtain a call identifier (e.g., a value that uniquely represents the call type) and additional parameters associated with the call.

The kernel driver 474 (described above as kernel driver 274 of FIG. 2) is installed within the VMM 463. The hook framework 476, which is part of the kernel driver 474, may be configured to detect calls initiated by the interpreter 472 or an application 470 processing the suspicious object 226 within the first VM 462 ₁ to certain OS system functions or API. Additionally, the hook framework 476 deployed within the VMM 463 may be configured to detect calls initiated by applications or interpreters operating in other VMs (e.g., second VM 462 ₂, etc.).

As described above, after loading, the kernel driver 474 conducts a multi-stage initialization process in response to a launching of the application 470 for processing the suspicious object 226. During the launch of the application 470, the monitor logic 471 are loaded. During or after loading of the monitor logic 471, the hook framework 476 of the VMM 463 may insert intercept points (or hooks) at certain system functions within the monitor logic 471 to allow the hook framework 476 to detect a function call (e.g., API call 477) that invokes a particular API and tracks usage of that particular API. Information associated with the API call 477 may be extracted by the hook framework 476 or monitoring logic 480 and stored for subsequent use by the classification logic 485. The classification logic 485 within the threat detection system 400 is responsible for determining whether the suspicious object 226 is malicious and an exploit attack is being conducted on the interpreter 472.

More specifically, the hook framework 476 is configured to intercept a first set of API calls associated with a certain type activity (or certain types of activities) that are directed to an API that is normally not accessed by the particular interpreter 472 operating within the first VM 462 ₁ as well as a second set of API calls associated with a certain type activity (or certain types of activities) that are directed to an API that is normally not accessed by the particular interpreter 473 operating within the second VM 462 ₂.

In response to detecting an API call 477 that is part of the first set of API calls, an active thread or process, which is running in the first VM 462 ₁ and involved in the processing of a portion of the script that caused invocation of the API call, is halted until a response to the API call 477 is returned. Hook framework 476 operating in cooperation with the monitoring logic 480 tracks usage of this API associated with the hooked API call when the interpreter 472 is part of the calling hierarchy and usage of the API by the interpreter 472 is considered an anomalous activity. The virtualized system resources 468 returns information 469 (e.g., pointer, data, etc.) in response to the API call 477 and virtual processing of the script continues. The hook framework 476 further support API calls 475 initiated by an active thread or process, which is running in the second VM 462 ₂ and involved in the processing of a portion of the script that caused invocation of the API call 475.

In summary, the hook framework 476 may be used to intercept (i) function calls directed to one or more selected APIs or equivalent operating system (e.g., guest or host OS) functions that are considered anomalous API calls for the interpreter 472 operating within the first VM 462 ₁ as well as (ii) function calls directed to one or more selected APIs or equivalent OS functions that are considered anomalous API calls for the interpreter 473 operating within the second VM 462 ₂. The hook framework 476 includes logic that extracts one or more features (e.g., arguments, etc.) from the function call. Similarly, these features may include a name of the function identified in the function call (e.g., API name), or other data within the arguments of the function call issued (or triggered) by the suspicious object 226 during processing within the first VM 462 ₁ or the second VM 462 ₂. The features may be stored in a data store 484 and are subsequently provided to (or accessible by) the classification logic 485 as part of VM-based results 479.

The kernel driver 474 further comprises the instrumentation framework 478 which, as described above, inserts intercept points (referred to as “instrumentations”) to prescribed locations within the interpreters 472 and 473 (or code operating with the interpreters 472 and 473) to detect certain types of activities that are anomalous (e.g., abnormal, unexpected, etc.) for these interpreters. These activities may correspond to attempted accesses of certain functions of the interpreters 472 and 473. The instrumentation framework 478 provides a higher level view of script/bytecode processing, by collecting higher level state information associated with the interpreters 472 and 473 being monitored.

As described above, it is contemplated that, where the interpreter 472 is positioned in the user mode, the operations of the hook framework 476 and the instrumentation framework 478 may be conducted in the user mode to intercept (or hook) certain system functions within the monitor logic 471. This allows for the detection of user-mode based exploit attacks. Additionally, as stated above, the monitoring logic 480 may reside in the user mode as well.

IV. General Operational Flow

Referring to FIG. 5, an exemplary embodiment of a stack illustrating a flow of operations controlled by the hook framework 276 and instrumentation framework 278 of FIG. 2 is shown. The flow of operations associated with the hook framework 476 and instrumentation framework 478 of FIG. 4 are similar to the below-described operations of the hook framework 276 and instrumentation framework 278 of FIG. 2, albeit the frameworks 476/478 support flows within multiple virtual machines.

Herein, as shown in FIG. 5, a script 500 is executed by an application, which invokes the interpreter 272 of FIG. 2. After loading of the kernel driver 274 into the kernel space associated with the VM 262, where the kernel driver 274 includes the hook framework 276, instrumentation framework 274, monitoring logic 280, correlation logic 282, activity reporting logic 360 and configuration processor 510, the kernel driver 274 conducts a multi-stage initialization process in response to a launching of an application that is processing the script 500. During the launch of the application, the hook framework 276 may insert intercept points (“hooks”) at certain locations within monitor logic 271 that may be injected into the application that is processing the script 500. The hooks may operate as JUMP instructions to a prescribed memory location associated with the hook framework 276, which intercepts at least one call 530 that invokes a particular Application Programming Interface (API). The hook framework 276 tracks usage of that particular API. More specifically, upon intercepting the system (API) call 530, information associated with the API call 530 may be extracted and stored. The information provides evidence of an exploit attack on the interpreter 272 when the interpreter 272 is confirmed to be part of the calling hierarchy so that the system (API) call 530 is considered an abnormal (and potentially malicious) activity. This confirmation may be conducted by the hook framework 276, monitoring logic 280, correlation logic 282 or at the classification logic outside the sandboxed environment created by the VM.

Further shown in FIG. 5, during execution of the script 500, the application may load the interpreter 272. Around that time, the instrumentation framework 278 may insert intercept points (“instrumentations”) to detect a certain type of activity 540 that is anomalous (e.g., abnormal, unexpected, etc.) for the interpreter 272. This activity may correspond to an attempted access to a certain function of the interpreter 272. Hence, the instrumentation framework 278 may provide a higher level view of script processing, by collecting higher level state information associated with the interpreter 272. The state information provides evidence of an exploit attack when the interpreter 272 is invoking functions at different times, functions in a different sequence than normally observed, functions that are unexpectedly invoked.

The configuration processor 510 is adapted to receive configuration data (or file) 550 that comprises information to assist in the hooking and/or instrumenting of code operating with the VM during analysis of the suspicious object 226 including the script 500. The information includes interpreter metadata 560, expected activities 570 for the interpreter 272, and unexpected activities 580 for the interpreter 272. The interpreter metadata 560 comprises information that assists the interception point frameworks to control the interception of API calls and setting intercept points within the interpreter 272. This information includes an identifier 562 of the type of script 500 under analysis, a memory location 564 (e.g., user space or kernel space) that may indirectly categorize the type of interpreter under analysis, a version number 566 to identify the particular version of the interpreter (where multiple versions of the interpreter exist).

The expected activities 570 may be used by the hook framework 276 and/or instrumentation framework 278 as a white list for the internal and system-wide functions that are expected for use by each particular interpreter. In contrast, the unexpected activities 580 may be used by the hook framework 276 and/or instrumentation framework 278 as a black list that signifies intercept points (hooks) directed to calls (e.g., system, function, API calls) as well as intercept points (instrumentations) directed to internal functions within the interpreter 272.

V. General Endpoint Architecture

Referring now to FIG. 6, a system for detecting exploit attacks on an interpreter also may be performed by a security agent 600. Herein, the security agent 600 is stored within a memory 610 encased within a housing 625 of an endpoint device 620. Upon execution by a processor 630, the security agent 600 conducts dynamic analysis of at least a portion of information 640 received by a transceiver 650 of the endpoint device 620. Operating during normal run-time or as part of a sandboxed environment that is operating concurrently (e.g., at least partially at the same time) or alternatively with other run-time processes, the security agent 600 conducts dynamic (virtual) analysis of at least the portion of the information, including the suspicious object 126. The dynamic analysis includes processing of the script 660 that is part of the suspicious object and invokes an interpreter 670. The hook framework 680 and the instrumentation framework 690 monitor API calls and attempted accesses to segments of code within the interpreter 670, as described above. These monitored activities are stored in a data store 695 within the memory 610 along with the identifier associated with the monitored activity or identification of a system function invoked by the interpreter 670.

In the foregoing description, the invention is described with reference to specific exemplary embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. For instance, in lieu of a detection of an exploit attack on an interpreter, the interception point framework(s) may be utilized for a Just-In-Time (JIT) compiler. Additionally, the anomalous behavior may be determined by detecting activity other than hooked system or API calls. 

What is claimed is:
 1. A non-transitory storage medium including software, executed by a processor and operating within a virtual machine, to detect an exploit attack on an interpreter based on processing of an object by an application in the virtual machine and detecting a loading of interpreter by the application, the software comprising: a hook framework that, responsive to launching of the application, is configured to insert one or more intercept points into the interpreter or software operating in cooperation with the interpreter for detecting calls associated with one or more types of activities that are normally not conducted by the interpreter and represent a potential exploit attack; and an instrumentation framework configured to insert one or more intercept points into the interpreter instrumented as a first type of interpreter or software operating in cooperation with the interpreter to detect any activities conducted by the interpreter that differ from activities conducted by the first type of interpreter and represent a potential exploit attack.
 2. The non-transitory storage medium of claim 1, wherein the one or more intercept points inserted by the hook framework are configured to detect a certain type or types of Application Programming Interface (API) calls.
 3. The non-transitory storage medium of claim 1, wherein the one or more intercept points inserted by the hook framework are configured to detect a different type or types of Application Programming Interface (API) calls, depending on a type of the interpreter.
 4. The non-transitory storage medium of claim 1, wherein the one or more intercept points inserted by the hook framework are configured to detect one or more Application Programming Interface (API) calls each corresponding to a selected software call of the calls associated with one or more types of activities, where the detected one or more API calls being an anomalous activity by the interpreter.
 5. The non-transitory storage medium of claim 1, wherein the software operating in cooperation with the interpreter includes software being part of a kernel driver.
 6. The non-transitory storage medium of claim 5, wherein the software further comprises monitoring logic to track activities associated with the certain type or types of API calls after detection.
 7. The non-transitory storage medium of claim 6, wherein the kernel driver further comprises a correlation logic to aggregate and categorize the monitored data from the monitoring logic in order to determine whether any detected anomalous activities denote an exploit attack on the interpreter.
 8. The non-transitory storage medium of claim 1, wherein the instrumentation framework further collects state information associated with the interpreter.
 9. The non-transitory storage medium of claim 8, wherein the state information provides evidence of an exploit attack when the interpreter is invoking (i) functions at different times, (ii) functions in a different sequence than normally observed, or (iii) functions unexpectedly.
 10. The non-transitory storage medium of claim 1, wherein the hook framework is configured to intercept system calls including Application Programming Interface (API) calls and the instrumentation framework is configured to collect state information associated with the interpreter.
 11. The non-transitory storage medium of claim 1 further comprising classification logic communicatively coupled to the hook framework and the instrumentation framework, the classification logic being configured to determine whether any anomalous activities detected by the hook framework and any anomalous activities detected by the instrumentation framework denote an exploit attack on the interpreter.
 12. The non-transitory storage medium of claim 11 further comprising reporting logic communicatively coupled to the classification logic, the reporting logic being configured to generate an alert signal to identify that the object is classified as malicious.
 13. A computerized method for detecting an exploit attack on a software component based on processing of an object by an application in a virtual machine, comprising: detecting a loading of the software component by the application when processing of the object; responsive to launching of the application, inserting one or more intercept points, by a hook framework, into the software component or software operating in cooperation with the software component for detecting calls associated with one or more types of activities that are normally not conducted by the software component and represent a potential exploit attack; and inserting one or more intercept points, by an instrumentation framework, into either (i) the software component instrumented as a first type of software component or (ii) software operating in cooperation with the software component to detect any activities conducted by the software component that differ from activities conducted by the first type of software component and represent a potential exploit attack.
 14. The computerized method of claim 13, wherein the one or more intercept points inserted by the hook framework are configured to detect a certain type or types of Application Programming Interface (API) calls.
 15. The computerized method of claim 13, wherein the software component is an interpreter.
 16. The computerized method of claim 15, wherein the one or more intercept points inserted by the hook framework are configured to detect a different type or types of Application Programming Interface (API) calls, depending on a type of the interpreter.
 17. The computerized method of claim 15, wherein the one or more intercept points inserted by the hook framework are configured to detect one or more Application Programming Interface (API) calls each corresponding to a selected software call of the calls associated with one or more types of activities, where the detected one or more API calls being an anomalous activity by the interpreter.
 18. The computerized method of claim 15, wherein the software operating in cooperation with the interpreter includes software being part of a kernel driver.
 19. The computerized method of claim 18, wherein the software further comprises monitoring logic to track activities associated with the certain type or types of API calls after detection.
 20. The computerized method of claim 19, wherein the kernel driver further comprises a correlation logic to aggregate and categorize the monitored data from the monitoring logic in order to determine whether any detected anomalous activities denote an exploit attack on the interpreter.
 21. The computerized method of claim 15 further comprising collecting, by the instrumentation framework, state information associated with the interpreter.
 22. The computerized method of claim 21, wherein the state information provides evidence of an exploit attack when the interpreter is invoking (i) functions at different times, (ii) functions in a different sequence than normally observed, or (iii) functions unexpectedly.
 23. The computerized method of claim 15 further comprising intercepting system calls including Application Programming Interface (API) calls by the hook framework and collecting state information associated with the interpreter from the instrumentation framework.
 24. The computerized method of claim 13, wherein the software component includes a Just-In-Time (JIT) compiler.
 25. The computerized method of claim 13 further comprising: determining, by classification logic communicatively coupled to the hook framework and the instrumentation framework, whether any anomalous activities detected by the hook framework and any anomalous activities detected by the instrumentation framework denote an exploit attack on the software component.
 26. The computerized method of claim 25 further comprising: generating an alert signal, by reporting logic communicatively coupled to the classification logic, to identify that the object is classified as malicious.
 27. A system for detecting an exploit attack on a software component, comprising: one or more processors; and a non-transitory storage medium communicatively coupled to the one or more processors, the non-transitory storage medium includes software, when executed by the one or more processors, to (i) process an object by an application in a virtual machine, and (ii) detect a launching of the software component by the application when processing the object; wherein the software further comprising: a hook framework that, responsive to the launching of the application, is configured to insert one or more intercept points into the software component or software operating in cooperation with the software component for detecting calls associated with one or more types of activities that are normally not conducted by the software component and represent a potential exploit attack, and an instrumentation framework configured to insert one or more intercept points into either (i) the software component instrumented as a first type of software component or (ii) software operating in cooperation with the software component to detect any activities conducted by the software component that differ from activities conducted by the first type of software component and represent a potential exploit attack.
 28. The system of claim 27, wherein the one or more intercept points inserted by the hook framework are configured to detect a certain type or types of Application Programming Interface (API) calls.
 29. The system of claim 27, wherein the software component is an interpreter.
 30. The system of claim 29, wherein the one or more intercept points inserted by the hook framework are configured to detect a different type or types of Application Programming Interface (API) calls, depending on a type of the interpreter.
 31. The system of claim 29, wherein the one or more intercept points inserted by the hook framework are configured to detect one or more Application Programming Interface (API) calls each corresponding to a selected software call of the calls associated with one or more types of activities, where the detected one or more API calls being an anomalous activity by the interpreter.
 32. The system of claim 29, wherein the software operating in cooperation with the interpreter includes software being part of a kernel driver.
 33. The system of claim 32, wherein the software further comprises monitoring logic to track activities associated with the certain type or types of API calls after detection.
 34. The system of claim 33, wherein the kernel driver further comprises a correlation logic to aggregate and categorize the monitored data from the monitoring logic in order to determine whether any detected anomalous activities denote an exploit attack on the interpreter.
 35. The system of claim 29, wherein the instrumentation framework further collects state information associated with the interpreter.
 36. The system of claim 35, wherein the state information provides evidence of an exploit attack when the interpreter is invoking (i) functions at different times, (ii) functions in a different sequence than normally observed, or (iii) functions unexpectedly.
 37. The system of claim 29, wherein the hook framework is configured to intercept system calls including Application Programming Interface (API) calls and the instrumentation framework is configured to collect state information associated with the interpreter.
 38. The system of claim 27, wherein the software component includes a Just-In-Time (JIT) compiler.
 39. The system of claim 27 further comprising classification logic communicatively coupled to the hook framework and the instrumentation framework, the classification logic being configured to determine whether any anomalous activities detected by the hook framework and any anomalous activities detected by the instrumentation framework denote an exploit attack on the software component.
 40. The system of claim 39 further comprising reporting logic communicatively coupled to the classification logic, the reporting logic being configured to generate an alert signal to identify that the object is classified as malicious.
 41. The system of claim 27, wherein the one or more processors correspond to one or more hardware processors. 